# (c) 2006-2009 Ian Bicking, Mike Beachy, and contributors
# Licensed under the MIT license:
# http://www.opensource.org/licenses/mit-license.php
r"""
minimock is a simple library for doing Mock objects with doctest.
When using doctest, mock objects can be very simple.

Here's an example of something we might test, a simple email sender::

    >>> import smtplib
    >>> def send_email(from_addr, to_addr, subject, body):
    ...     conn = smtplib.SMTP('localhost')
    ...     msg = 'To: %s\nFrom: %s\nSubject: %s\n\n%s' % (
    ...         to_addr, from_addr, subject, body)
    ...     conn.sendmail(from_addr, [to_addr], msg)
    ...     conn.quit()

Now we want to make a mock ``smtplib.SMTP`` object.  We'll have to
inject our mock into the ``smtplib`` module::

    >>> smtplib.SMTP = Mock('smtplib.SMTP')
    >>> smtplib.SMTP.mock_returns = Mock('smtp_connection')

Now we do the test::

    >>> send_email('ianb@colorstudy.com', 'joe@example.com',
    ...            'Hi there!', 'How is it going?')
    Called smtplib.SMTP('localhost')
    Called smtp_connection.sendmail(
        'ianb@colorstudy.com',
        ['joe@example.com'],
        'To: joe@example.com\nFrom: ianb@colorstudy.com\nSubject: Hi there!\n\nHow is it going?')
    Called smtp_connection.quit()

Voila!  We've tested implicitly that no unexpected methods were called
on the object.  We've also tested the arguments that the mock object
got.  We've provided fake return calls (for the ``smtplib.SMTP()``
constructor).  These are all the core parts of a mock library.  The
implementation is simple because most of the work is done by doctest.
"""

__all__ = ["mock", "restore", "Mock", "TraceTracker", "assert_same_trace"]

import builtins
import sys
import inspect
import doctest
import re
import textwrap
try:
   from io import StringIO
except ImportError:
   from io import StringIO

# A list of mocked objects. Each item is a tuple of (original object,
# namespace dict, object name, and a list of object attributes).
#
mocked = []

def lookup_by_name(name, nsdicts):
   """
    Look up an object by name from a sequence of namespace dictionaries.
    Returns a tuple of (nsdict, obj_name, attrs); nsdict is the namespace
    dictionary the name was found in, obj_name is the name of the base object
    the name is bound to, and the attrs list is the chain of attributes
    of the object that completes the name.

        >>> import os
        >>> nsdict, obj_name, attrs = lookup_by_name("os.path.isdir", 
        ...     (locals(),))
        >>> obj_name, attrs
        ('os', ['path', 'isdir'])
        >>> getattr(getattr(nsdict[obj_name], attrs[0]), attrs[1])
        <function isdir at ...>
        >>> lookup_by_name("os.monkey", (locals(),))
        Traceback (most recent call last):
          ...
        NameError: name 'os.monkey' is not defined

    """
   for nsdict in nsdicts:
      attrs = name.split(".")
      names = []

      while attrs:
         names.append(attrs.pop(0))
         obj_name = ".".join(names)

         if obj_name in nsdict:
            attr_copy = attrs[:]
            tmp = nsdict[obj_name]
            try:
               while attr_copy:
                  tmp = getattr(tmp, attr_copy.pop(0))
            except AttributeError:
               pass
            else:
               return nsdict, obj_name, attrs

   raise NameError("name '%s' is not defined" % name)

def mock(name, nsdicts=None, mock_obj=None, **kw):
   """
    Mock the named object, placing a Mock instance in the correct namespace
    dictionary. If no iterable of namespace dicts is provided, use
    introspection to get the locals and globals of the caller of this
    function, as well as __builtin__.__dict__ to allow mocking built-ins.

    All additional keyword args are passed on to the Mock object
    initializer.

    An example of how os.path.isfile is replaced::

        >>> import os
        >>> os.path.isfile
        <function isfile at ...>
        >>> isfile_id = id(os.path.isfile)
        >>> mock("os.path.isfile", returns=True)
        >>> os.path.isfile
        <Mock ... os.path.isfile>
        >>> os.path.isfile("/foo/bar/baz")
        Called os.path.isfile('/foo/bar/baz')
        True
        >>> mock_id = id(os.path.isfile)
        >>> mock_id != isfile_id
        True

    A second mock object will replace the first, but the original object
    will be the one replaced with the replace() function.

        >>> mock("os.path.isfile", returns=False)
        >>> mock_id != id(os.path.isfile)
        True
        >>> restore()
        >>> os.path.isfile
        <function isfile at ...>
        >>> isfile_id == id(os.path.isfile)
        True

    Test mocking a built-in function::

        >>> mock("raw_input", returns="okay")
        >>> raw_input()
        Called raw_input()
        'okay'
        >>> restore()

    Test mocking and restoring a classmethod and staticmethod::

        >>> class Test(object):
        ...     @classmethod
        ...     def cm(cls):
        ...         return 'cm'
        ...     @staticmethod
        ...     def sm():
        ...         return 'sm'
        >>> mock('Test.cm', returns='mocked')
        >>> mock('Test.sm', returns='mocked')
        >>> Test.cm()
        Called Test.cm()
        'mocked'
        >>> Test.sm()
        Called Test.sm()
        'mocked'
        >>> restore()
        >>> Test.cm()
        'cm'
        >>> Test.sm()
        'sm'

    Test mocking a proxy object::

        >>> class Proxy(object):
        ...     def __init__(self, obj):
        ...         self._obj = obj
        ...     def __getattr__(self, name):
        ...         return getattr(self._obj, name)
        >>> import os
        >>> os = Proxy(os)
        >>> os.path.isfile
        <function isfile at ...>
        >>> mock('os.path.isfile')
        >>> os.path.isfile
        <Mock ... os.path.isfile>
        >>> restore()

    """
   if nsdicts is None:
      stack = inspect.stack()
      try:
         # stack[1][0] is the frame object of the caller to this function
         globals_ = stack[1][0].f_globals
         locals_ = stack[1][0].f_locals
         nsdicts = (locals_, globals_, builtins.__dict__)
      finally:
         del (stack)

   if mock_obj is None:
      mock_obj = Mock(name, **kw)

   nsdict, obj_name, attrs = lookup_by_name(name, nsdicts)

   # Get the original object and replace it with the mock object.
   tmp = nsdict[obj_name]

   # if run from a doctest, nsdict may point to a *copy* of the
   # global namespace, so instead use tmp.func_globals if present.
   # we use isinstance(gettattr(...), dict) rather than hasattr
   # because if tmp is itself a mock object, tmp.func_globals will
   # return another mock object
   if isinstance(getattr(tmp, 'func_globals', None), dict):
      nsdict = tmp.__globals__
   if not attrs:
      original = tmp
      nsdict[obj_name] = mock_obj
   else:
      for attr in attrs[:-1]:
         try:
            tmp = tmp.__dict__[attr]
         except KeyError:
            tmp = getattr(tmp, attr)
      try:
         original = tmp.__dict__[attrs[-1]]
      except KeyError:
         original = getattr(tmp, attrs[-1])
      setattr(tmp, attrs[-1], mock_obj)

   mocked.append((original, nsdict, obj_name, attrs))

def restore():
   """
    Restore all mocked objects.
    """
   global mocked

   # Restore the objects in the reverse order of their mocking to assure
   # the original state is retrieved.
   while mocked:
      original, nsdict, name, attrs = mocked.pop()
      if not attrs:
         nsdict[name] = original
      else:
         tmp = nsdict[name]
         for attr in attrs[:-1]:
            try:
               tmp = tmp.__dict__[attr]
            except KeyError:
               tmp = getattr(tmp, attr)
         setattr(tmp, attrs[-1], original)

def assert_same_trace(tracker, want):
   r"""
    Check that the mock objects using ``tracker`` have been used as expected.

    :param tracker: a :class:`TraceTracker` instance
    :param want: the expected :class:`Printer` output
    :type want: string
    :raises: :exc:`AssertionError` if the expected and observed outputs don't
        match

    Example::

            >>> tt = TraceTracker()
            >>> m = Mock('mock_obj', tracker=tt)
            >>> m.some_meth('dummy argument')
            >>> assert_same_trace(tt,
            ...     "Called mock_obj.some_meth('dummy argument')\n")
            >>> assert_same_trace(tt, "Non-matching trace")
            Traceback (most recent call last):
            ...
            AssertionError...
    """
   assert tracker.check(want), tracker.diff(want)

class AbstractTracker(object):
   def __init__(self, *args, **kw):
      raise NotImplementedError

   def call(self, *args, **kw):
      raise NotImplementedError

   def set(self, *args, **kw):
      raise NotImplementedError

class Printer(AbstractTracker):
   """Prints all calls to the file it's instantiated with.
    Can take any object that implements `write'.
    """
   def __init__(self, file):
      self.file = file

   def call(self, func_name, *args, **kw):
      parts = [repr(a) for a in args]
      parts.extend('%s=%r' % (items) for items in sorted(kw.items()))
      msg = 'Called %s(%s)' % (func_name, ', '.join(parts))
      if len(msg) > 80:
         msg = 'Called %s(\n    %s)' % (func_name, ',\n    '.join(parts))
      print(msg, file=self.file)

   def set(self, obj_name, attr, value):
      """
        >>> z = Mock('z', show_attrs=True)
        >>> z.a = 2
        Set z.a = 2
        """
      print('Set %s.%s = %r' % (obj_name, attr, value), file=self.file)

class TraceTracker(Printer):
   """
    :class:`AbstractTracker` implementation for using MiniMock in non-
    :mod:`doctest` tests. Follows the pattern of recording minimocked
    object usage as strings, then using the facilities of :mod:`doctest`
    to assert the correctness of these usage strings.
    """
   def __init__(self, *args, **kw):
      self.out = StringIO()
      super(TraceTracker, self).__init__(self.out, *args, **kw)
      self.checker = MinimockOutputChecker()
      self.options = doctest.ELLIPSIS
      self.options |= doctest.NORMALIZE_INDENTATION
      self.options |= doctest.NORMALIZE_FUNCTION_PARAMETERS
      self.options |= doctest.REPORT_UDIFF

   def check(self, want):
      r"""
        Compare observed MiniMock usage with that which we expected.

        :param want: the :class:`Printer` output that results from expected
            usage of mocked objects
        :type want: string
        :rtype: a ``True`` value if the check passed, ``False`` otherwise

        Example::

            >>> tt = TraceTracker()
            >>> m = Mock('mock_obj', tracker=tt)
            >>> m.some_meth('arg1')
            >>> tt.check("Called mock_obj.some_meth('arg1')")
            True
            >>> tt.clear()
            >>> m.some_meth('arg2')
            >>> tt.check("does not match")
            False
        """
      return self.checker.check_output(want, self.dump(), optionflags=self.options)

   def diff(self, want):
      r"""
        Analyse differences between observed MiniMock usage and that which
        we expected, if any.

        :param want: the :class:`Printer` output that results from expected
            usage of mocked objects
        :type want: string
        :rtype: a string summary of differences between the observed usage and
            the ``want`` parameter

        Example::

            >>> tt = TraceTracker()
            >>> m = Mock('mock_obj', tracker=tt)
            >>> m.some_meth('dummy argument')
            >>> tt.diff("does not match")
            "Expected:\n    does not match\nGot:\n    Called mock_obj.some_meth('dummy argument')\n"
            >>> tt.diff("Called mock_obj.some_meth('dummy argument')")
            ''
        """
      if self.check(want):
         # doctest's output_difference always returns a diff, even if
         # there's no difference: short circuit that feature.
         return ''
      else:
         return self.checker.output_difference(doctest.Example("", want), self.dump(),
                                               optionflags=self.options)

   def dump(self):
      r"""
        Return the MiniMock object usage so far.

        Example::

            >>> tt = TraceTracker()
            >>> m = Mock('mock_obj', tracker=tt)
            >>> m.some_meth('dummy argument')
            >>> tt.dump()
            "Called mock_obj.some_meth('dummy argument')\n"
        """
      return self.out.getvalue()

   def clear(self):
      """Clear the MiniMock object usage that has been tracked so far.
        """
      self.out.truncate(0)

def normalize_function_parameters(text):
   r"""
    Return a version of ``text`` with function parameters normalized.

        The normalisations performed are:

        * Remove any whitespace sequence between an opening
          parenthesis '(' and a subsequent non-whitespace character.

        * Remove any whitespace sequence between a non-whitespace
          character and a closing parenthesis ')'.

        * Ensure a comma ',' and a subsequent non-whitespace character
          are separated by a single space ' '.

    Example::

        >>> tt = TraceTracker()
        >>> foo = Mock("foo", tracker=tt)
        >>> expect_mock_output = '''\
        ...     Called foo.bar('baz')
        ...     '''
        >>> foo.bar('baz')
        >>> tt.check(expect_mock_output)
        True
        >>> tt.clear()
        >>> expect_mock_output = '''\
        ...     Called foo.bar(
        ...         'baz')
        ...     '''
        >>> foo.bar('baz')
        >>> tt.check(expect_mock_output)
        True
    """
   normalized_text = text
   normalize_map = {
      re.compile(r"\(\s+(\S)"): r"(\1",
      re.compile(r"(\S)\s+\)"): r"\1)",
      re.compile(r",\s*(\S)"): r", \1",
   }
   for search_pattern, replace_pattern in list(normalize_map.items()):
      normalized_text = re.sub(search_pattern, replace_pattern, normalized_text)

   return normalized_text

doctest.NORMALIZE_INDENTATION = (doctest.register_optionflag('NORMALIZE_INDENTATION'))
doctest.NORMALIZE_FUNCTION_PARAMETERS = (
   doctest.register_optionflag('NORMALIZE_FUNCTION_PARAMETERS'))

class MinimockOutputChecker(doctest.OutputChecker, object):
   """Class for matching output of MiniMock objects against expectations.
    """
   def check_output(self, want, got, optionflags):
      if (optionflags & doctest.NORMALIZE_INDENTATION):
         want = textwrap.dedent(want).rstrip()
         got = textwrap.dedent(got).rstrip()
      if (optionflags & doctest.NORMALIZE_FUNCTION_PARAMETERS):
         want = normalize_function_parameters(want)
         got = normalize_function_parameters(got)
      output_match = super(MinimockOutputChecker, self).check_output(want, got, optionflags)
      return output_match

   check_output.__doc__ = doctest.OutputChecker.check_output.__doc__

class _DefaultTracker(object):
   def __repr__(self):
      return '(default tracker)'

DefaultTracker = _DefaultTracker()
del _DefaultTracker

class Mock(object):
   def __init__(self, name, returns=None, returns_iter=None, returns_func=None, raises=None,
                show_attrs=False, tracker=DefaultTracker, **kw):
      _obsetattr = object.__setattr__
      _obsetattr(self, 'mock_name', name)
      _obsetattr(self, 'mock_returns', returns)
      if returns_iter is not None:
         returns_iter = iter(returns_iter)
      _obsetattr(self, 'mock_returns_iter', returns_iter)
      _obsetattr(self, 'mock_returns_func', returns_func)
      _obsetattr(self, 'mock_raises', raises)
      _obsetattr(self, 'mock_attrs', kw)
      _obsetattr(self, 'mock_show_attrs', show_attrs)
      if tracker is DefaultTracker:
         tracker = Printer(sys.stdout)
      _obsetattr(self, 'mock_tracker', tracker)

   def __repr__(self):
      return '<Mock %s %s>' % (hex(id(self)), self.mock_name)

   def __call__(self, *args, **kw):
      if self.mock_tracker is not None:
         self.mock_tracker.call(self.mock_name, *args, **kw)
      return self._mock_return(*args, **kw)

   def _mock_return(self, *args, **kw):
      if self.mock_raises is not None:
         raise self.mock_raises
      elif self.mock_returns is not None:
         return self.mock_returns
      elif self.mock_returns_iter is not None:
         try:
            return next(self.mock_returns_iter)
         except StopIteration:
            raise Exception("No more mock return values are present.")
      elif self.mock_returns_func is not None:
         return self.mock_returns_func(*args, **kw)
      else:
         return None

   def __getattr__(self, attr):
      if attr not in self.mock_attrs:
         if self.mock_name:
            new_name = self.mock_name + '.' + attr
         else:
            new_name = attr
         self.mock_attrs[attr] = Mock(new_name, show_attrs=self.mock_show_attrs,
                                      tracker=self.mock_tracker)
      return self.mock_attrs[attr]

   def __setattr__(self, attr, value):
      if attr in frozenset((
            'mock_raises',
            'mock_returns',
            'mock_returns_func',
            'mock_returns_iter',
            'mock_tracker',
            'mock_show_attrs',
      )):
         if attr == 'mock_returns_iter' and value is not None:
            value = iter(value)
         object.__setattr__(self, attr, value)
      else:
         if self.mock_show_attrs and self.mock_tracker is not None:
            self.mock_tracker.set(self.mock_name, attr, value)
         self.mock_attrs[attr] = value

__test__ = {
   "Mock":
   r"""
    Test setting various "mock_" attributes on an existing Mock object.

    >>> m = Mock('mock_obj', tracker=None)
    >>> m.mock_returns = 42
    >>> m()
    42
    >>> m.mock_returns = None
    >>> m.mock_returns_func = lambda x: x*x
    >>> m(3)
    9
    >>> m.mock_returns_func = None
    >>> m.mock_returns_iter = [True, False]
    >>> m()
    True
    >>> m()
    False
    >>> m.mock_returns_iter = None
    >>> m.mock_raises = ValueError
    >>> try:
    ...     m()
    ... except ValueError:
    ...     pass
    ... else:
    ...     raise AssertionError('m() should have raised ValueError')
    >>> m.mock_tracker = Printer(sys.stdout)
    >>> m.mock_show_attrs = True
    >>> m.a = 2
    Set mock_obj.a = 2
    """,
   "mock":
   r"""
    An additional test for mocking a function accessed directly (i.e.
    not via object attributes).

    >>> import os
    >>> rename = os.rename
    >>> orig_id = id(rename)
    >>> mock("rename")
    >>> mock_id = id(rename)
    >>> mock("rename")
    >>> mock_id != id(rename)
    True
    >>> restore()
    >>> orig_id == id(rename) == id(os.rename)
    True

    The example from the module docstring, done with the mock/restore
    functions.

    >>> import smtplib
    >>> def send_email(from_addr, to_addr, subject, body):
    ...     conn = smtplib.SMTP('localhost')
    ...     msg = 'To: %s\nFrom: %s\nSubject: %s\n\n%s' % (
    ...         to_addr, from_addr, subject, body)
    ...     conn.sendmail(from_addr, [to_addr], msg)
    ...     conn.quit()

    >>> mock("smtplib.SMTP", returns=Mock('smtp_connection'))
    >>> send_email('ianb@colorstudy.com', 'joe@example.com',
    ...            'Hi there!', 'How is it going?')
    Called smtplib.SMTP('localhost')
    Called smtp_connection.sendmail(
        'ianb@colorstudy.com',
        ['joe@example.com'],
        'To: joe@example.com\nFrom: ianb@colorstudy.com\nSubject: Hi there!\n\nHow is it going?')
    Called smtp_connection.quit()
    >>> restore()

    """,
}

if __name__ == '__main__':
   import doctest
   doctest.testmod(optionflags=doctest.ELLIPSIS)
